Revisiting Actor Programming in C++

The actor model of computation has gained significant popularity over the last decade. Its high level of abstraction makes it appealing for concurrent applications in parallel and distributed systems. However, designing a real-world actor framework that subsumes full scalability, strong reliability, and high resource efficiency requires many conceptual and algorithmic additives to the original model. In this paper, we report on designing and building CAF, the "C++ Actor Framework". CAF targets at providing a concurrent and distributed native environment for scaling up to very large, high-performance applications, and equally well down to small constrained systems. We present the key specifications and design concepts---in particular a message-transparent architecture, type-safe message interfaces, and pattern matching facilities---that make native actors a viable approach for many robust, elastic, and highly distributed developments. We demonstrate the feasibility of CAF in three scenarios: first for elastic, upscaling environments, second for including heterogeneous hardware like GPGPUs, and third for distributed runtime systems. Extensive performance evaluations indicate ideal runtime behaviour for up to 64 cores at very low memory footprint, or in the presence of GPUs. In these tests, CAF continuously outperforms the competing actor environments Erlang, Charm++, SalsaLite, Scala, ActorFoundry, and even the OpenMPI.Comment: 33 page

SoK: A Data-driven View on Methods to Detect Reflective Amplification DDoS Attacks Using Honeypots

In this paper, we revisit the use of honeypots for detecting reflective amplification attacks. These measurement tools require careful design of both data collection and data analysis including cautious threshold inference. We survey common amplification honeypot platforms as well as the underlying methods to infer attack detection thresholds and to extract knowledge from the data. By systematically exploring the threshold space, we find most honeypot platforms produce comparable results despite their different configurations. Moreover, by applying data from a large-scale honeypot deployment, network telescopes, and a real-world baseline obtained from a leading DDoS mitigation provider, we question the fundamental assumption of honeypot research that convergence of observations can imply their completeness. Conclusively we derive guidance on precise, reproducible honeypot research, and present open challenges.Comment: camera-read

Redesigning the Network Layer for Distributed Actors in CAF

Das Aktormodell baut auf transparenter Nachrichtenübermittlung und einem starken Fehlermodell auf. Es verspricht Skalierbarkeit über nebenläu ge Kerne und verteilte Knoten. Hochverteilte Systeme, die skalierbar auf Anwender oder Verarbeitungsanforderungen abgestimmt sind, können von dem hohen Abstraktionsniveau von Aktoren pro tieren. Das C++ Actor Framework (CAF) ist eine native Implementierung des Aktormodell, die einen e zienten Nachrichtenaustausch beinhaltet. In dieser Arbeit analysieren wir die Verteilungsschicht in CAF mit dem Ergebnis, dass unterschiedliche Leistungsgarantien in lokalen und verteilten Umgebungen die geforderte Verteilungstransparenz beeinträchtigen. Wir diskutieren die Aspekte Zuverlässigkeit, Erreichbarkeit und Bindung an ein Transportprotokoll im Kontext der Aktorkommunikation, bevor Garantien für die Kommunikation im CAF abgeleitet werden. Auf dieser Grundlage schlagen wir eine Neugestaltung der CAF-Netzwerkschicht vor. Diese erlaubt den Austausch von Transportprotokollen, definiert eine konsistente Auswahl von Garantien für Nachrichtenübertragung zwischen Aktoren und entfernt Routing-Fähigkeiten aus dem CAF-Overlay. Die Erweiterung der CAF-Netzwerkschicht um UDP bietet eine erste Bewertung der Funktionalität und ebnet den Weg für eine vollständige Implementierung des vorgeschlagenen Designs.The actor model offers network transparent message passing and a strong failure model. It promises scalability over concurrent cores and distributed nodes. Highly distributed systems designed to scale with users or processing demands can benefit from its high level of abstraction. The C++ Actor Framework (CAF) is a native implementation of the actor model with an efficient message passing layer. In this work, we examine the actor communication in CAF and find distribution transparency to be impacted by varying guarantees for concurrency and distribution. The aspects of reliability, reachability and transport binding are reconsidered in the context of actor communication before deriving guarantees for the communication in CAF. To address these differences, we propose a redesign of the CAF network layer. This introduces exchangeable transport protocols, defines a consistent set of guarantees for message passing between actors and removes routing capabilities from the CAF overlay. The augmentation of the CAF network layer with UDP provides a first assessment of the functionality and paves the way for a complete implementation of the proposed design

libcppa on SIMD machines - GPGPU computing using transparent C++11 actors and OpenCL

In recent years, graphics processing units (GPU) developed from single-purpose pipelines to clusters of data-parallel programmable units. Their performance is no longer reserved for graphics calculations, but can be used for general-purpose computing. A highly parallel architecture enables GPUs to outperform CPUs by several orders of magnitude for various use cases. Frameworks like OpenCL or CUDA give access to their capabilities. The objective of this work is to raise the abstraction level of GPGPU programming by combining it with the actor model. The actor model provides a high level approach to concurrency and offers mechanisms to built fault tolerant distributed systems. Our work focuses specifically on OpenCL and libcppa, an actor library written in C++11. We present the concept of the OpenCL-enabled actor, which offers an easy way to deploy code to GPUs. It is integrated into the runtime environment of libcppa and gives rise to transparent message passing in distributed systems and on heterogeneous hardware. Actors on the GPU are instantiated by the function spawn_cl, which handles the OpenCL setup process in the background. Messages sent to the OpenCL actor are used as arguments to trigger a kernel execution. Once the kernel finishes, the actor sent the results to the actor that requested the calculation. We examined our implementation for overhead over the native OpenCL API and find that the induced overhead is negligible.In den letzten Jahren haben sich Grafikprozessoren (GPU) von dedizierten Pipelines zu Gruppen von datenparallelen programmierbaren Kernen entwickelt. Ihre Rechenleitung ist nicht mehr nur für graphische Instruktionen reserviert, sondern lässt sich für universelle Berechnungen nutzen. Eine hochparallele Architektur führt dazu, dass GPUs in manchen Bereichen eine deutlich höhere Leistung erzielen als CPUs. Spezielle Frameworks wie CUDA oder OpenCL haben sich als Programmierschnittstelle für diese Systeme etabliert. Das Ziel dieser Arbeit ist es, GPUs von einer höhere Abstraktionsebene aus programmierbar zu machen, indem wir GPGPU mit dem Actor Model vereinen. Das Actor Model schafft eine Abstraktion über parallele Systeme und bietet Möglichkeiten verteilte, fehlertolerante Systeme zu bauen. Im Speziellen beschäftigen wir uns mit OpenCL und der C++11 Actor Library libcppa. Wir präsentieren den OpenCL Actor, der eine einfache Möglichkeit bietet, Code auf einer GPU auszuführen. Er ist in die Laufzeitumgebung von libcppa integrieret und ermöglicht transparentes Message Passing in verteilten Systemen auf heterogener Hardware. Actoren für die GPU werden durch die Funktion spawn_cl instanziiert, die das Setup für OpenCL im Hintergrund durchführt. Empfangene Nachrichten werden vom OpenCL Actor als Argumente für ein auf der GPU ausgeführtes Program genutzt. Die Ergebnisse aus der Berechnung werden anschließend an der Actor gesandt, der die Berechnung initiiert hat. Eine empirische Untersuchung der Mehraufwände zeigt deutlich, dass der induzierte Mehraufwand unserer Implementierung gegenüber den nativen OpenCL API vernachlässigbar ist

Embedded Actors - Towards distributed programming in the IoT

The long-term vision of an Internet of Things (IoT) is approaching reality and leading hardware vendors expect shipment of 50 billion devices in the near future. Emerging Internet standards will enable this huge number of embedded machines to interconnect and cooperate---and raise the challenge of building suitable software environments that provide scalability, reliability, and security at an efficient level. In this paper, we introduce such an approach---a modified actor model and a corresponding runtime environment. In contrast to common tools, it offers a higher level of abstraction to design and program applications for constrained devices, while remaining efficient, reliable, and open to include the security extensions from the agenda of the IETF

OpenCL Actors -- Adding Data Parallelism to Actor-based Programming with CAF

The actor model of computation has been designed for a seamless support of concurrency and distribution. However, it remains unspecific about data parallel program flows, while available processing power of modern many core hardware such as graphics processing units (GPUs) or coprocessors increases the relevance of data parallelism for general-purpose computation. In this work, we introduce OpenCL-enabled actors to the C++ Actor Framework (CAF). This offers a high level interface for accessing any OpenCL device without leaving the actor paradigm. The new type of actor is integrated into the runtime environment of CAF and gives rise to transparent message passing in distributed systems on heterogeneous hardware. Following the actor logic in CAF, OpenCL kernels can be composed while encapsulated in C++ actors, hence operate in a multi-stage fashion on data resident at the GPU. Developers are thus enabled to build complex data parallel programs from primitives without leaving the actor paradigm, nor sacrificing performance. Our evaluations on commodity GPUs, an Nvidia TESLA, and an Intel PHI reveal the expected linear scaling behavior when offloading larger workloads. For sub-second duties, the efficiency of offloading was found to largely differ between devices. Moreover, our findings indicate a negligible overhead over programming with the native OpenCL API

Reconsidering Reliability in Distributed Actor Systems

Frameworks inspired by the actor model have recently attracted much attention. Actor systems promise transparent concurrency and distribution by combining message passing with a strong failure model. In this work, we re-examine distribution transparency and find that reliability breaks the promise in several dimensions. Solutions for regaining awareness of failures are briefly discussed

CAF - The C++ Actor Framework for Scalable and Resource-efficient Applications

The actor model of computation has gained significant popularity over the last decade. Its high level of abstraction combined with its flexibility and efficiency makes it appealing for large applications in concurrent and distributed regimes. In this paper, we report on our work of designing and building CAF, the "C++ Actor Framework". CAF targets at providing an extremely scalable native environment for building high-performance concurrent applications and distributed systems. Based on our previous library &tring; libcppa, CAF significantly extends its scopes of application and operation, as well as the range of scalability. The particular contributions of this paper are threefold. First we present the design and implementation of a type-safe messaging interface for actors that rules out a category of runtime errors and facilitates robust software design. Second we introduce a runtime inspection shell as a first building block for convenient debugging of distributed actors. Finally we enhance the scheduling facilities and improve scaling up to high numbers of concurrent processors. Extensive performance evaluations indicate ideal runtime behaviour for up to 64 cores at very low memory footprint. In these tests, CAF clearly outperforms competing actor environments